{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对应`tf.kears` 版本的03，在训练过程中加入更多的控制\n",
    "\n",
    "1. 训练中保存/保存最好的模型\n",
    "2. 早停 \n",
    "3. 训练过程可视化\n",
    "\n",
    "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
    "\n",
    "```shell\n",
    "pip install tensorflow\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:00.685460500Z",
     "start_time": "2025-02-20T13:25:57.619722400Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\17362\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=11, micro=5, releaselevel='final', serial=0)\n",
      "matplotlib 3.8.2\n",
      "numpy 1.26.3\n",
      "pandas 2.1.4\n",
      "sklearn 1.3.2\n",
      "torch 2.6.0+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:01.937048400Z",
     "start_time": "2025-02-20T13:26:00.687460600Z"
    }
   },
   "outputs": [],
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:01.943660900Z",
     "start_time": "2025-02-20T13:26:01.938048400Z"
    }
   },
   "outputs": [],
   "source": [
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n",
      "torch.Size([32, 1, 28, 28])\n",
      "torch.Size([32])\n"
     ]
    }
   ],
   "source": [
    "# 查看数据\n",
    "for datas, labels in train_loader:\n",
    "    print(datas.shape)\n",
    "    print(labels.shape)\n",
    "    break\n",
    "#查看val_loader\n",
    "for datas, labels in val_loader:\n",
    "    print(datas.shape)\n",
    "    print(labels.shape)\n",
    "    break"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:01.963002Z",
     "start_time": "2025-02-20T13:26:01.941661300Z"
    }
   }
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:01.969424900Z",
     "start_time": "2025-02-20T13:26:01.962002500Z"
    }
   },
   "outputs": [],
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 300),  # in_features=784, out_features=300\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(300, 100),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(100, 10),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "    \n",
    "model = NeuralNetwork()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.049671700Z",
     "start_time": "2025-02-20T13:26:01.969424900Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        #datas.shape [batch size, 1, 28, 28]\n",
    "        #labels.shape [batch size]\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item()) # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测, axis=-1 表示最后一个维度,因为logits.shape [batch size, 10]，所以axis=-1表示对最后一个维度求argmax，即对每个样本的10个类别的概率求argmax，得到最大概率的类别, preds.shape [batch size]\n",
    "        pred_list.extend(preds.cpu().numpy().tolist()) # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list) # 验证集准确率\n",
    "    return np.mean(loss_list), acc # 返回验证集平均损失和准确率\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorBoard 可视化\n",
    "\n",
    "pip install tensorboard\n",
    "训练过程中可以使用如下命令启动tensorboard服务。注意使用绝对路径，否则会报错\n",
    "\n",
    "```shell\n",
    " tensorboard  --logdir=\"D:\\BaiduSyncdisk\\pytorch\\chapter_2_torch\\runs\" --host 0.0.0.0 --port 8848\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.352122200Z",
     "start_time": "2025-02-20T13:26:02.052675300Z"
    }
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs) # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):#graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape)) # 画模型图\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            ) # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        ) # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        ) # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss) # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc) # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate) # 画lr曲线\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.353118100Z",
     "start_time": "2025-02-20T13:26:02.335606Z"
    }
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir # 保存路径\n",
    "        self.save_step = save_step # 保存步数\n",
    "        self.save_best_only = save_best_only # 是否只保存最好的模型\n",
    "        self.best_metrics = -1 # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir): # 如果不存在保存路径，则创建\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0: #每隔save_step步保存一次\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None # 必须传入metric\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\")) # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\")) # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.353118100Z",
     "start_time": "2025-02-20T13:26:02.343337500Z"
    }
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience # 多少个epoch没有提升就停止训练\n",
    "        self.min_delta = min_delta # 最小的提升幅度\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:#用准确率\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1 # 计数器加1，下面的patience判断用到\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "80000"
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "500*32*5"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.353118100Z",
     "start_time": "2025-02-20T13:26:02.346774800Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.355624600Z",
     "start_time": "2025-02-20T13:26:02.349614300Z"
    }
   },
   "outputs": [],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device) # 数据放到device上\n",
    "                labels = labels.to(device) # 标签放到device上\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传，计算梯度，更新参数，这里是更新模型参数\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 切换到验证集模式\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train() # 切换回训练集模式\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"], # 取出当前学习率\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc) # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc) # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:# 验证集准确率不再提升，则停止训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.485539400Z",
     "start_time": "2025-02-20T13:26:02.356624600Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "Parameter containing:\ntensor([-2.7042e-02,  1.1163e-03, -1.1410e-02,  6.6706e-03,  1.5905e-02,\n        -1.1560e-02,  3.4667e-02, -1.0156e-02,  1.5700e-02, -1.0112e-02,\n        -3.2470e-02, -3.8738e-04, -7.4881e-04, -3.3668e-02, -1.4136e-02,\n        -3.2776e-02,  2.4366e-02,  2.3628e-02,  1.1890e-02, -1.0731e-03,\n         7.9827e-03,  1.4293e-02, -3.2549e-02,  1.2004e-02, -6.3570e-03,\n         6.5241e-03,  1.5203e-02, -2.4009e-02, -7.5539e-03, -1.4474e-02,\n        -1.2618e-02, -2.7090e-02,  1.5783e-02,  2.7416e-02,  3.2716e-02,\n        -1.6312e-02, -2.5956e-02,  2.5863e-02, -2.7175e-02, -2.0753e-02,\n        -1.7715e-02,  3.1738e-02,  2.5975e-02,  1.5644e-02, -6.8921e-03,\n         2.7139e-03,  1.6918e-02, -2.5161e-02,  1.8025e-02, -5.3522e-03,\n        -2.7876e-02,  2.3306e-02,  2.1081e-02, -3.4954e-02,  1.3519e-02,\n         2.5996e-02, -1.6592e-02,  3.2109e-02, -1.7563e-02, -1.9301e-02,\n         2.9217e-02,  1.0814e-02,  2.5818e-02,  3.3226e-02,  1.8744e-02,\n         3.2627e-02, -2.3265e-02, -1.0596e-02,  1.2701e-02, -2.1550e-02,\n         2.6651e-02,  3.0250e-02,  1.3267e-02, -3.4190e-02,  3.3473e-02,\n        -1.3699e-02,  2.3478e-02,  2.5139e-02, -2.4951e-02,  1.3832e-02,\n         1.5634e-02,  1.4282e-02, -2.0505e-02, -9.4239e-03, -1.0929e-02,\n         4.8462e-04,  1.1084e-02,  3.5228e-02,  1.1152e-02, -5.5356e-03,\n         2.0905e-02,  1.5663e-03,  2.4972e-02, -1.6061e-02, -3.5509e-02,\n         2.7689e-02,  9.9286e-03,  1.2752e-02, -2.6095e-03, -1.7542e-02,\n         1.2057e-02, -3.4661e-02,  5.7581e-03, -7.9023e-03,  2.1783e-03,\n        -1.6086e-02, -3.0265e-02,  3.1673e-02, -2.3096e-02,  2.7413e-02,\n         2.3402e-02, -1.2270e-02, -1.5031e-02,  3.1439e-02, -1.3241e-02,\n        -2.8263e-02,  6.1254e-03,  2.5061e-02,  7.4166e-03,  1.9472e-02,\n         3.3646e-02,  2.5005e-02, -2.0399e-02,  1.5996e-02, -7.1503e-03,\n        -1.6440e-02, -1.5001e-02, -1.8540e-02,  2.1495e-02, -9.3075e-03,\n        -6.2426e-03,  1.9829e-02, -8.0404e-03, -7.6894e-03,  1.4103e-02,\n        -2.3685e-02,  2.3471e-02, -2.1052e-02,  2.6528e-03, -1.3327e-02,\n         7.5527e-03,  2.8361e-03,  2.6828e-03, -1.4081e-02, -3.7851e-03,\n        -1.9212e-02, -8.6221e-03, -2.9005e-03,  2.9934e-02,  5.7599e-03,\n        -2.9426e-02, -1.3140e-03,  9.9265e-03, -5.4316e-03,  9.2446e-03,\n        -1.2890e-02,  2.9041e-02,  1.3807e-02, -2.5785e-04,  5.0061e-03,\n        -7.5700e-04,  1.7317e-02, -1.2225e-02,  1.6928e-02, -1.5116e-02,\n        -3.8927e-03, -7.9275e-03,  3.9097e-03, -9.6784e-03,  9.7972e-03,\n        -3.1276e-02,  1.0031e-04,  1.9914e-02, -2.1577e-02,  2.5461e-02,\n         1.8279e-02, -2.4671e-03, -1.3488e-03,  1.1902e-02, -2.1894e-04,\n         9.2122e-03, -2.9054e-05, -2.9738e-02,  3.3569e-03, -1.6706e-02,\n        -2.3313e-03, -5.4097e-03,  3.5597e-02, -1.9050e-02, -3.2033e-02,\n         3.2574e-02, -1.3710e-02,  3.4193e-02, -4.4299e-03,  3.2951e-02,\n        -3.2627e-02,  7.5018e-03,  2.9284e-03, -2.4242e-02,  2.1438e-02,\n        -2.4415e-02,  2.0350e-02,  1.4290e-02, -3.0262e-02, -1.3154e-02,\n         1.0520e-02,  1.3393e-02, -1.1963e-02,  2.6754e-02,  1.5724e-02,\n         5.9786e-04, -3.2744e-02,  7.0102e-03,  1.4587e-02,  1.0663e-02,\n        -2.4175e-02, -9.5523e-03,  7.6840e-04,  7.3183e-03, -2.8483e-02,\n        -5.3012e-03, -9.1836e-03, -3.4402e-02, -4.7842e-04,  2.9827e-02,\n         4.9974e-03, -1.3613e-02, -2.0313e-02, -3.1625e-03,  1.6935e-02,\n        -9.6080e-03,  1.6156e-02, -1.9722e-02, -3.4204e-02, -1.5323e-02,\n         4.5437e-03, -1.9405e-02,  1.5489e-02,  1.1839e-03,  6.9104e-03,\n         3.5860e-03,  1.1394e-03,  6.0665e-03,  7.7411e-04, -3.2660e-02,\n         3.3526e-02,  1.8160e-02, -4.3161e-03, -1.5435e-02, -2.0961e-02,\n         1.3811e-02,  2.9202e-02,  5.6933e-04,  1.1078e-02,  2.6412e-02,\n        -1.1429e-02, -4.2108e-04, -2.0546e-02, -3.3179e-02, -2.5661e-02,\n         2.0943e-02, -2.6340e-02, -1.3633e-02, -1.1823e-03, -2.1308e-02,\n        -4.9927e-03,  2.6924e-02,  1.1614e-02,  3.4512e-02, -6.6453e-03,\n         1.4219e-02,  1.5235e-02, -5.3688e-03,  5.0262e-03,  1.3555e-02,\n         1.3630e-02, -2.3753e-02,  2.9450e-02, -3.3510e-02, -2.6439e-02,\n        -3.2670e-02,  9.5261e-03, -2.5879e-02,  2.0916e-02,  2.5996e-02,\n         2.1057e-02, -1.6225e-03, -1.0920e-02, -1.7147e-02, -3.4653e-03,\n        -1.9125e-03, -6.1010e-03, -1.6276e-02, -7.5698e-03,  1.0039e-02,\n        -3.5009e-02,  2.2186e-02,  1.3969e-02, -2.8677e-02,  2.5531e-02],\n       requires_grad=True)"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(model.parameters())[1] #可学习的模型参数"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.492387300Z",
     "start_time": "2025-02-20T13:26:02.483539900Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "odict_keys(['linear_relu_stack.0.weight', 'linear_relu_stack.0.bias', 'linear_relu_stack.2.weight', 'linear_relu_stack.2.bias', 'linear_relu_stack.4.weight', 'linear_relu_stack.4.bias'])"
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.state_dict().keys()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:26:02.494389500Z",
     "start_time": "2025-02-20T13:26:02.488957200Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 19%|█▉        | 36000/187500 [02:29<10:28, 240.86it/s, epoch=19]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 19 / global_step 36000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    val_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    "    )"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:28:31.976219500Z",
     "start_time": "2025-02-20T13:26:02.493389700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "#帮我写个enumerate例子\n",
    "for i, item in enumerate([\"a\", \"b\", \"c\"]):\n",
    "    print(i, item)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:28:31.979879500Z",
     "start_time": "2025-02-20T13:28:31.979879500Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:28:32.157313400Z",
     "start_time": "2025-02-20T13:28:31.979879500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns) #因为有loss和acc两个指标，所以画个子图\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5)) #fig_num个子图，figsize是子图大小\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        x_data=range(0, train_df.index[-1], 5000) #每隔5000步标出一个点\n",
    "        axs[idx].set_xticks(x_data)\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", x_data)) #map生成labal\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [],
   "source": [
    "model = NeuralNetwork() #上线时加载模型\n",
    "model = model.to(device)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-20T13:28:32.167172600Z",
     "start_time": "2025-02-20T13:28:32.157313400Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-20T13:28:32.705413700Z",
     "start_time": "2025-02-20T13:28:32.162670400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3514\n",
      "accuracy: 0.8756\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
